// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package objabi

import (
	"bytes"
	"flag"
	"fmt"
	"internal/buildcfg"
	"io"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"strings"
)

func Flagcount(name, usage string, val *int) {
	flag.Var((*count)(val), name, usage)
}

func Flagfn1(name, usage string, f func(string)) {
	flag.Var(fn1(f), name, usage)
}

func Flagprint(w io.Writer) {
	flag.CommandLine.SetOutput(w)
	flag.PrintDefaults()
}

func Flagparse(usage func()) {
	flag.Usage = usage
	os.Args = expandArgs(os.Args)
	flag.Parse()
}

// expandArgs在提供的切片中展开“响应文件”参数。
// None
// “response file”参数以“@”开头，其余的以“@”开头
// 参数是带有CR或CRLF分隔参数的文件名。每个
// 命名文件中的参数也可以包含响应文件
// 论据。见第18468期。
// None
// 如果输入不包含，则返回的切片“out”别名为“in”
// 任何响应文件参数。
// None
// TODO:处理不同目录中递归扩展的相对路径？
// 这个有规格吗？是否允许相对路径？
func expandArgs(in []string) (out []string) {
	// 在我们看到“@”参数之前，out为零。
	for i, s := range in {
		if strings.HasPrefix(s, "@") {
			if out == nil {
				out = make([]string, 0, len(in)*2)
				out = append(out, in[:i]...)
			}
			slurp, err := ioutil.ReadFile(s[1:])
			if err != nil {
				log.Fatal(err)
			}
			args := strings.Split(strings.TrimSpace(strings.Replace(string(slurp), "\r", "", -1)), "\n")
			for i, arg := range args {
				args[i] = DecodeArg(arg)
			}
			out = append(out, expandArgs(args)...)
		} else if out != nil {
			out = append(out, s)
		}
	}
	if out == nil {
		return in
	}
	return
}

func AddVersionFlag() {
	flag.Var(versionFlag{}, "V", "print version and exit")
}

var buildID string // 由链接器填写

type versionFlag struct{}

func (versionFlag) IsBoolFlag() bool { return true }
func (versionFlag) Get() interface{} { return nil }
func (versionFlag) String() string   { return "" }
func (versionFlag) Set(s string) error {
	name := os.Args[0]
	name = name[strings.LastIndex(name, `/`)+1:]
	name = name[strings.LastIndex(name, `\`)+1:]
	name = strings.TrimSuffix(name, ".exe")

	p := ""

	if s == "goexperiment" {
		// test/run.go使用它来发现完整的
		// 实验标签。汇报一切。
		p = " X:" + strings.Join(buildcfg.AllExperiments(), ",")
	} else {
		// 如果启用的实验与默认值不同，
		// 包括这一差异。
		if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
			p = " X:" + goexperiment
		}
	}

	// go命令调用-V=full以获取唯一标识符
	// 对于这个工具。假设发布版本足够
	// 对于发行版，但在开发过程中，我们包含了完整的
	// 构建二进制文件的ID，以便在编译器发生更改时
	// 重建，我们注意到并重建所有包。
	if s == "full" {
		if strings.HasPrefix(buildcfg.Version, "devel") {
			p += " buildID=" + buildID
		}
	}

	fmt.Printf("%s version %s%s\n", name, buildcfg.Version, p)
	os.Exit(0)
	return nil
}

// count是一个flag.Value，类似于flag.Bool和flag.Int。
// 如果用作-name，则递增计数，但-name=x设置计数。
// 用于详细标志-v。
type count int

func (c *count) String() string {
	return fmt.Sprint(int(*c))
}

func (c *count) Set(s string) error {
	switch s {
	case "true":
		*c++
	case "false":
		*c = 0
	default:
		n, err := strconv.Atoi(s)
		if err != nil {
			return fmt.Errorf("invalid count %q", s)
		}
		*c = count(n)
	}
	return nil
}

func (c *count) Get() interface{} {
	return int(*c)
}

func (c *count) IsBoolFlag() bool {
	return true
}

func (c *count) IsCountFlag() bool {
	return true
}

type fn1 func(string)

func (f fn1) Set(s string) error {
	f(s)
	return nil
}

func (f fn1) String() string { return "" }

// decode arg对参数进行解码。
// None
// 此函数是使用并行编码器进行测试的公共函数。
func DecodeArg(arg string) string {
	// 如果没有编码，则快速路径输出。
	if !strings.ContainsAny(arg, "\\\n") {
		return arg
	}

	// 我们不能使用strings.Builder，因为它必须在引导时工作。
	var b bytes.Buffer
	var wasBS bool
	for _, r := range arg {
		if wasBS {
			switch r {
			case '\\':
				b.WriteByte('\\')
			case 'n':
				b.WriteByte('\n')
			default:
				// 这不应该发生。唯一到达这里的反斜杠
				// 应以独占方式编码“\n”和“\\”。
				panic("badly formatted input")
			}
		} else if r == '\\' {
			wasBS = true
			continue
		} else {
			b.WriteRune(r)
		}
		wasBS = false
	}
	return b.String()
}
